puts '---------------函数------------------'
ar=[1, 2]
def push_in_array(ar, item)
  ar.push item
end

push_in_array ar, 'nihao'
puts ar

def bigger_than_zero?(i)
  if i > 0
    return true
  else
    return false
  end
end

puts bigger_than_zero? 1
puts bigger_than_zero? -1
#puts push_in_array.class 首先def函数不是对象
#不能在def函数里再def一个函数，不能传入 返回def函数

puts '-----------------代码块----------------'
#普通block 直接传入，不能返回，在内部执行，能访问内部域，
#用&bl 能传入返回访问内部域, 是Proc类的对象，闭包么？但是返回的时候没法访问内部域了啊
ar.each { |item| puts item } #也可以用 do / end
2.times { puts '你好啊' }
def block_tester(&bl) #这里不算函数参数，不能显式传入Proc对象
  puts bl.class
  aif="a inner field"
  bif="b inner field"
  yield bif #效率高？ 写ruby还考虑效率么？写的快就好
  bl.call bif
  #return {puts "its a new block generate inside"} #不能这样返回
  bl
end
#re=block_tester {|x| puts "代码块作为一等参数（闭包）,#{x},#{aif}" } # 不能这样玩
#re.call "gived field"

puts '------------------Proc---------------'
#Proc文档：Proc对象是一个绑定了很多本地参数的blocks代码块，一旦绑定后，这些代码你就能在不同的上下文调用，使用这些参数。
#结论： 真丶闭包
pro=Proc.new do |x|
  puts x + " hehe"
end

def proc_tester(inP)
  a=" is great"
  puts inP.class
  inP.call a
  return Proc.new {|x| puts x + a}
end
p=proc_tester pro
p.call "ruby"

puts '---------------Lambda------------------'
#Lambda表达式
lam=lambda {|x| puts x + " hehe"}
def lambda_tester(inL)
  a=" is great"
  puts inL.class
  inL.call a
  return lambda {|x| puts x + a}
end
p=lambda_tester lam
p.call "ruby"